package com.nest.WorkNest.view;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.graphics.drawable.ColorDrawable;
import android.media.ExifInterface;
import android.net.Uri;
import android.provider.MediaStore;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnTouchListener;
import android.view.ViewGroup.LayoutParams;
import android.view.animation.AnimationUtils;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.PopupWindow;

import com.nest.WorkNest.R;
import com.nest.WorkNest.data.AppGlobal;
import com.nest.WorkNest.tools.FileUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @描述 图片选择弹出框, 生成的图片每次都不一样
 * @作者 何琳
 * @创建时间 2014-10-20 下午2:42:53
 */
public abstract class SelectPicPopupWindow extends PopupWindow implements
        OnClickListener {

    private Button btn_take_photo, btn_pick_photo, btn_cancel;
    private View mMenuView;
    private Activity context;

    private String picName = "picTemp.jpg"; // 图片，用于保存的
    private final String picFileDir = AppGlobal.externalFileDir + File.separator + "pic"
            + File.separator;
    private final int IMAGE_CODE = 0;
    private final int CAREMA_CODE = 1;
    private final int PHOTO_PICKED_WITH_DATA = 2;
    protected final int iconWidth = 90, iconHtight = 90;

    private LinearLayout ll_pop;

    /**
     * @return
     * @描述 获取图片缓存目录
     * @作者 何琳
     * @创建时间 2014-12-19 上午11:02:29
     */
    public String getPicFilePath() {
        return picFileDir + picName;
    }

    public SelectPicPopupWindow(Activity context) {
        super(context);
        this.context = context;
        LayoutInflater inflater = (LayoutInflater) context
                .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        mMenuView = inflater.inflate(R.layout.layout_pic_popup, null);
        btn_take_photo = (Button) mMenuView.findViewById(R.id.btn_take_photo);
        btn_pick_photo = (Button) mMenuView.findViewById(R.id.btn_pick_photo);
        btn_cancel = (Button) mMenuView.findViewById(R.id.btn_cancel);
        ll_pop = (LinearLayout) mMenuView.findViewById(R.id.pop_layout);
        ll_pop.startAnimation(AnimationUtils.loadAnimation(context, R.anim.activity_translate_in));
        btn_cancel.setOnClickListener(this);
        btn_pick_photo.setOnClickListener(this);
        btn_take_photo.setOnClickListener(this);
        // 设置SelectPicPopupWindow的View
        this.setContentView(mMenuView);
        // 设置SelectPicPopupWindow弹出窗体的宽
        this.setWidth(LayoutParams.MATCH_PARENT);
        // 设置SelectPicPopupWindow弹出窗体的高
        this.setHeight(LayoutParams.WRAP_CONTENT);
        // 设置SelectPicPopupWindow弹出窗体可点击
        this.setFocusable(true);
        // 设置SelectPicPopupWindow弹出窗体动画效果
        // this.setAnimationStyle(R.style.BottomPopTheme);
        // 实例化一个ColorDrawable颜色为半透明
        ColorDrawable dw = new ColorDrawable(0xb0000000);
        // 设置SelectPicPopupWindow弹出窗体的背景
        this.setBackgroundDrawable(dw);
        // mMenuView添加OnTouchListener监听判断获取触屏位置如果在选择框外面则销毁弹出框
        mMenuView.setOnTouchListener(new OnTouchListener() {
            public boolean onTouch(View v, MotionEvent event) {
                int height = mMenuView.findViewById(R.id.pop_layout).getTop();
                int y = (int) event.getY();
                if (event.getAction() == MotionEvent.ACTION_UP) {
                    if (y < height) {
                        dismiss();
                    }
                }
                return true;
            }
        });
    }

    @Override
    public void showAtLocation(View parent, int gravity, int x, int y) {
        ll_pop.startAnimation(AnimationUtils.loadAnimation(context, R.anim.activity_translate_in));
        super.showAtLocation(parent, gravity, x, y);
        // picName = UUID.randomUUID().toString()+".jpg";
    }

    @Override
    public void onClick(View v) {
        if (v.getId() == R.id.btn_cancel) {
            dismiss();
            ll_pop.clearAnimation();
        } else if (v.getId() == R.id.btn_take_photo) {
            // 拍照
            dismiss();
            ll_pop.clearAnimation();
            startCarema(this.context);
        } else if (v.getId() == R.id.btn_pick_photo) {
            // 从相册选择
            dismiss();
            ll_pop.clearAnimation();
            startAlbum(this.context);
        }
    }

    /**
     * @param fileDir
     * @param fileName
     * @return
     * @描述 返回一个存在的文件和路径
     * @作者 何琳
     * @创建时间 2014-12-19 下午2:46:28
     */
    private File getPicFile(String fileDir, String fileName) {
        File dir = new File(fileDir);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        File file = new File(fileDir, fileName);
        if (!file.exists()) {
            try {
                if (file.createNewFile()) {
                    return file;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return file;
    }

    /**
     * @描述: 开启拍照
     * @作者： 何琳
     * @创建时间： 2014-10-20 下午4:19:41 void
     */
    private void startCarema(Activity context) {
        Intent openCameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        Uri imageUri = Uri.fromFile(getPicFile(picFileDir, picName));
        // 指定照片保存路径（SD卡），camera.png为一个临时文件，每次拍照后这个图片都会被替换
        openCameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, imageUri);
        context.startActivityForResult(openCameraIntent, CAREMA_CODE);
    }

    /**
     * @描述: 开启相册
     * @作者： 何琳
     * @创建时间： 2014-10-20 下午4:19:30 void
     */
    private void startAlbum(Activity context) {
        // 使用intent调用系统提供的相册功能，使用startActivityForResult是为了获取用户选择的图片
        Intent intent = new Intent(Intent.ACTION_PICK,
                android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        context.startActivityForResult(intent, IMAGE_CODE);
    }

    private void doCropPhoto(Activity context, Uri data) {
        Intent cropIntent = getCropImageIntent(data);
        context.startActivityForResult(cropIntent, PHOTO_PICKED_WITH_DATA);
    }

    /**
     * 系统的裁剪图片默认对图片进行人脸识别， 当识别到有人脸时，会按aspectX和aspectY为1来处理，
     * 如果想设置成自定义的裁剪比例，需要设置noFaceDetection为true。
     * 即iintent.putExtra("noFaceDetection", true); 取消人脸识别功能。
     * <p/>
     * 附加选项 数据类型 描述 crop String 发送裁剪信号 aspectX int X方向上的比例 aspectY int Y方向上的比例
     * outputX int 裁剪区的宽 outputY int 裁剪区的高 scale boolean 是否保留比例 return-data
     * boolean 是否将数据保留在Bitmap中返回 data Parcelable 相应的Bitmap数据 circleCrop String
     * 圆形裁剪区域？ MediaStore.EXTRA_OUTPUT URI 将URI指向相应的file:///...，详见代码示例
     * <p/>
     * <p/>
     * 方法1：如果你将return-data设置为“true”，你将会获得一个与内部数据关联的Action，并且bitmap以此方式返回：(Bitmap
     * )extras.getParcelable("data")。注意：如果你最终要获取的图片非常大，那么此方法会给你带来麻烦，
     * 所以你要控制outputX和outputY保持在较小的尺寸。 方法2：
     * 如果你将return-data设置为“false”，那么在onActivityResult的Intent数据中你将不会接收到任何Bitmap
     * ，相反，你需要将MediaStore.EXTRA_OUTPUT关联到一个Uri，此Uri是用来存放Bitmap的。
     * android官方的文档显示，通过intent传递的文件最大不能超过1MB
     * ，所以这种方式切割图片通常不能超过400x400，我在我的图片软件里面采用的解决办法是
     * ，把切割的图片存储到临时文件，然后在返回的activity里面读取文件来处理，可以得到你想得到的任何尺寸！
     *
     * @param data
     * @return
     */
    private Intent getCropImageIntent(Uri data) {
        Intent intent = new Intent("com.android.camera.action.CROP"); // 调用系统相机截图功能
        intent.setDataAndType(data, "image/*");
        intent.putExtra("crop", "true");
        // aspectX aspectY 是宽高的比例
        intent.putExtra("aspectX", 1);
        intent.putExtra("aspectY", 1);
        intent.putExtra("scale", true);
        // outputX outputY 是裁剪图片宽高
        intent.putExtra("outputX",
                (int) (AppGlobal.screenDensityDpiRadio * iconWidth));
        intent.putExtra("outputY",
                (int) (AppGlobal.screenDensityDpiRadio * iconHtight));
        intent.putExtra("return-data", false);// true:不返回uri，false：返回uri
        intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
        intent.putExtra(MediaStore.EXTRA_OUTPUT,
                Uri.fromFile(getPicFile(picFileDir, picName)));
        return intent;
    }

    /**
     * 读取照片exif信息中的旋转角度
     *
     * @param path 照片路径
     * @return角度
     */
    private int readPictureDegree(String path) {
        int degree = 0;
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            int orientation = exifInterface.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }

    /**
     * @param requestCode
     * @param resultCode
     * @param data
     * @描述 该方法必须写在Activity的onActivityResult（）中。
     * @作者 何琳
     * @创建时间 2014-12-19 下午12:09:14
     */
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode != Activity.RESULT_OK) { // 此处的 RESULT_OK 是系统自定义得一个常量
            return;
        }
        // 此处的用于判断接收的Activity是不是你想要的那个
        if (requestCode == IMAGE_CODE) {
            Uri originalUri = data.getData(); // 获得图片的uri
            if (originalUri != null) {
                doCropPhoto(this.context, originalUri);
            }
        } else if (requestCode == CAREMA_CODE) {
            String cameraPath = getPicFilePath();
            int degree = readPictureDegree(cameraPath);
            BitmapFactory.Options options = new BitmapFactory.Options();
            // 先设置为TRUE不加载到内存中，但可以得到宽和高
            options.inJustDecodeBounds = true;
            options.inSampleSize = 1;
            // 将保存在本地的图片取出并缩小后显示在界面上
            Bitmap _bitmap = BitmapFactory.decodeFile(cameraPath, options);
            // 在内存中创建bitmap对象，这个对象按照缩放大小创建的
            options.inSampleSize = FileUtils.calculateInSampleSize(options,
                    (int) (AppGlobal.screenDensityDpiRadio * iconWidth),
                    (int) (AppGlobal.screenDensityDpiRadio * iconHtight));
            options.inJustDecodeBounds = false;
            _bitmap = BitmapFactory.decodeFile(cameraPath, options);

            Matrix m = new Matrix();
            int width = _bitmap.getWidth();
            int height = _bitmap.getHeight();
            m.setRotate(degree);
            _bitmap = Bitmap
                    .createBitmap(_bitmap, 0, 0, width, height, m, true);
            storeInSD(_bitmap, picName, picFileDir);
            doCropPhoto(this.context,
                    Uri.fromFile(getPicFile(picFileDir, picName)));
        } else if (requestCode == PHOTO_PICKED_WITH_DATA) {
            try {
                cropPhotoImage(getPicFilePath(),
                        BitmapFactory.decodeStream(context.getContentResolver()
                                .openInputStream(
                                        Uri.fromFile(getPicFile(picFileDir,
                                                picName)))));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 保存图片到文件中
     *
     * @Bitmap path
     * @name 图片的名字 格式 (xx.png)
     */
    public void storeInSD(Bitmap bitmap, String name, String _name) {
        File file = new File(_name);
        if (!file.exists()) {
            file.mkdirs();
        }
        File imageFile = new File(file, name);
        try {
            imageFile.createNewFile();
            FileOutputStream fos = new FileOutputStream(imageFile);
            bitmap.compress(CompressFormat.JPEG, 80, fos);
            fos.flush();
            fos.close();
            bitmap.recycle();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * @param bitmap
     * @描述 返回的图片bitmap
     * @作者 何琳
     * @创建时间 2014-12-19 下午12:08:31
     */
    public abstract void cropPhotoImage(String filePath, Bitmap bitmap);
}
